Przykad 8.1. Prosta realizacja algorytmu Forda-Fulkersona w jzyku Java
public class FordFulkerson {
   FlowNetwork network;     /** Reprezentuje problem sieci przepywowej */
   Search searchMethod;     /** Metoda poszukiwawcza */

   // Zbuduj egzemplarz problemu do obliczenia maksymalnego przepywu
   // w danej sieci za pomoc zadanej metody poszukiwawczej znajdowania
   // cieki powikszajcej
   public FordFulkerson (FlowNetwork network, Search method) {
      this.network = network;
      this.searchMethod = method;
   }

   // Oblicz maksymalny przepyw sieci przepywowej. Wyniki oblicze
   // s zapamitane w obiekcie sieci przepywowej
   public boolean compute() {
      boolean augmented = false;
      while (searchMethod.findAugmentingPath(network.vertices)) {
         processPath(network.vertices);
         augmented = true;
      }
      return augmented;
   }

   // Znajd krawd w ciece powikszajcej o najniszym potencjale
   // do zwikszenia i powiksz o t wielko przepywy w ciece od
   // rda do ujcia
   protected void processPath(VertexInfo []vertices) {
      int v = network.sinkIndex;
      int delta = Integer.MAX_VALUE;  // ma by znalezione najmniejszy
      while (v != network.sourceIndex) {
         int u = vertices[v].previous;
         int flow;
         if (vertices[v].forward) {
            // Przednie krawdzie mog by podregulowane przez
            // przepustowo pozosta na krawdzi
            flow = network.edge(u, v).capacity  network.edge(u, v).flow;
         } else {
            // Tylne krawdzie mog by tylko zredukowane o istniejcy
            // w nich przepyw
            flow = network.edge(u, v).flow;
         }
         if (flow < delta) { delta = flow; }   // mniejszy przepyw kandydujcy
         v = u;   // podaj odwrotn drog ku rdu
      }

      // Podreguluj ciek (przednim si dodaje, tylnym ujmuje) o delt
      v = network.sinkIndex;
      while (v != network.sourceIndex) {
         int u = vertices.previous;
         if (vertices[v].forward) {
            network.edge(u, v).flow += delta;
         } else {
            network.edge(u, v).flow -= delta;
         }
         v = u;   // podaj odwrotn drog ku rdu
      }
      Arrays.fill(network.vertices, null);   // przygotuj do nastpnej iteracji
   }
}
